Lambda the Ultimate

The paper The Polyadic pi-Calculus: a Tutorial (1991) by Robin Milner doesn't appear to have been mentioned on the front page previously of LtU before. I think it is worth pointing to for beginners, since it appears to do a good job of covering the basics of pi-Calculus.

Abstract: The pi-calculus is a model of concurrent computation based upon the notion of naming . It is first presented in its simplest and original form, with the help of several illustrative applications. Then it is generalized from monadic to polyadic form. Semantics is done in terms of both a reduction system and a version of labelled transitions called commitment ; the known algebraic axiomatization of strong bisimilarity is given in the new setting, and so also is a characterization in modal logic....

For those fairly new to the group, pi-calculus is a formal calculus for studying concurrent computation. This would be a good thread for others not only to comment on this paper, but to mention other good entry points for the study of concurrency, and other calculi related to the pi-calculus.

YubNub is an online command-line community extensible search engine, or as they say "a (social) command line" for the web.

Some commands which may be of interest to the community are

• ltu - Lambda-the-Ultimate.org
• scholar - Google scholar
• cs - Citeseer
• oeis - Online Encyclopedia of Integer Sequences

You can also easily create your own commands. Please share any new commands you create or find which may be relevant for the community.

[Edit: Removed "plre - Programming Language Research Engine" from the main list, since it was criticized as being self-promotional.]

TM (transactional memory) provides a new concurrency-control construct that avoids the pitfalls of locks and significantly eases concurrent programming. It brings to mainstream parallel programming proven concurrency-control concepts used for decades by the database community. Transactional-language constructs are easy to use and can lead to programs that scale. By avoiding deadlocks and automatically allowing fine-grained concurrency, transactional-language constructs enable the programmer to compose scalable applications safely out of thread-safe libraries.

Nothing new here for LtU regulars, I guess, but you may still want to check out this column.

CUFP 2006

The goal of CUFP is to build a community for users of functional programming languages and technology...

abstracts and slides

eskimo: experimenting with skeletons in the shared address model. M. Aldinucci, 2003.

We discuss the lack of expressivity in some skeleton-based parallel programming frameworks. The problem is further exacerbated when approaching irregular problems and dealing with dynamic data structures. Shared memory programming has been argued to have substantial ease of programming advantages for this class of problems. We present the eskimo library which represents an attempt to merge the two programming models by introducing skeletons in a shared memory framework.

Based on some simple extensions to C, the library allows to work on large distributed structures following compositional functional semantics.

The basic idea under eskimo is to abstract both (dynamic) data structures and application flow of control in such a way that they are orthogonalized.

The most active members of LtU for the most part already have a solid foundation in logic. For the rest of us interested in language design, but who are not already logicians here is a brief reading list on logic, focusing on natural deduction, the preferred method of expressing type systems.

• Proofs and Types
• Daniel Clemente's Introduction to Natural Logic
• Proof, Theory and Philosophy by Greg Restall
• Chapter 2 (Natural Deduction) of Frank Pfenning's Handouts on Automated Theorem Proving
• Proofs are Programs by Philip Wadler
• Chapter on Natural Deduction from Ernest Lepore's book Meaning and Argument.
• The Unusual Effectiveness of Logic in Computer Science by Halpern et al
• PDF slides on sequent calculus and natural deduction by Christoph Benzmüller

More experienced members of LtU may perhaps consider contributing to the discussion with comments on the suggested reading or alternative suggestions.

[Edit: removed A History of Natural Deduction and Elementary Logic Textbooks by Jeff Pelletier and added several new links as suggested by Charles Stewart and falcon.]

Directness and liveness in the morphic user interface construction environment, John H. Maloney and Randall B. Smith, 1995.

Morphic is a user interface construction environment that strives to embody directness and liveness. Directness means a user interface designer can initiate the process of examining or changing the attributes, structure, and behavior of user interface components by pointing at their graphical representations directly. Liveness means the user interface is always active and reactive-objects respond to user actions, animations run, layout happens, and information displays update continuously. Four implementation techniques work together to support directness and liveness in Morphic: structural reification, layout reification, ubiquitous animation, and live editing.

Morphic was developed in Self and then adopted by Squeak. Reading this paper makes Squeak more interesting to click around in!

Back to the future: the story of Squeak, a practical Smalltalk written in itself by Dan Ingalls, Ted Kaehler, John Maloney, Scott Wallace, Alan Kay, 1997.

Squeak is an open, highly-portable Smalltalk implementation whose virtual machine is written entirely in Smalltalk, making it easy to debug, analyze, and change. To achieve practical performance, a translator produces an equivalent C program whose performance is comparable to commercial Smalltalks.

Other noteworthy aspects of Squeak include: a compact object format that typically requires only a single word of overhead per object; a simple yet efficient incremental garbage collector for 32-bit direct pointers; efficient bulk-mutation of objects; extensions of BitBlt to handle color of any depth and anti-aliased image rotation and scaling; and real-time sound and music synthesis written entirely in Smalltalk.

This paper is so good that it's hard to believe it was written after 1990!

A Bjarne Stroustrup interview about programming and about his language design philosophy. Two choice quotes:

I want elegant and efficient code. Sometimes I get it. These dichotomies (between efficiency versus correctness, efficiency versus programmer time, efficiency versus high-level, et cetera.) are bogus.

TR: In The Design and Evolution of C++, you claim that Kierkegaard was an influence on your conception of the language. Is this a joke?

BS: A bit pretentious, maybe, but not a joke. A lot of thinking about software development is focused on the group, the team, the company. This is often done to the point where the individual is completely submerged in corporate "culture" with no outlet for unique talents and skills. Corporate practices can be directly hostile to individuals with exceptional skills and initiative in technical matters. I consider such management of technical people cruel and wasteful. Kierkegaard was a strong proponent for the individual against "the crowd" and has some serious discussion of the importance of aesthetics and ethical behavior. I couldn't point to a specific language feature and say, "See, there's the influence of the nineteenth-century philosopher," but he is one of the roots of my reluctance to eliminate "expert level" features, to abolish "misuses," and to limit features to support only uses that I know to be useful. I'm not particularly fond of Kierkegaard's religious philosophy, though.

Now go read the whole thing, or go directly to the discussion already raging in the LtU disucssion group.

Lemonodor directs our attention to an interesting comp.lang.list post listing several of the key elements that make Lisp "different".

Don't miss the list of consequences for successful software design in Lisp at the end of the post:

* when in doubt design software to be dynamic (changeable at any time).

* when in doubt design software to be introspective

* when in doubt design software to be reflective